由于近期学业繁重QAQ,所以我就不说废话了,直接上代码~

朴素贝叶斯进行文本词汇分类

from numpy import *

#词表到向量的转换
#创建实验样本,返回的是进行词条切分后的文档集合,
#还有一个类别标签——侮辱性的or非侮辱性的
def loadDataSet():
    postingList=[['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],
                 ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
                 ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
                 ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
                 ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
                 ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]
    #1 代表侮辱性文字   0代表正常言论
    classVec = [0,1,0,1,0,1]
    return postingList,classVec
    
#创建一个包含在所有文档中出现的不重复的词的列表    
def createVocabList(dataSet):
    vocabSet=set([])
    #document:['my', 'dog', 'has', 'flea', 'problems', 'help', 'please']
    for document in dataSet:
        #求并集
        vocabSet=vocabSet|set(document)
        #print(vocabSet)
    return list(vocabSet)
    
#参数为词汇表以及某个文档,输出的是文档向量
#输出的向量的每一个元素为1或0,表示词汇表中
#的单词在输入文档中是否出现
def setOfWords2Vec(vocabList,inputSet):
    #创建一个所含元素都为0的向量
    returnVec=[0]*len(vocabList)
    #遍历文档中的所有单词,如果出现了词汇表中的单词,
    #则将输出文档的对应值设为1
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)]=1
        else:
            print("the word: %s is not in my Vocabulary!"%word)
    return returnVec
    

    

#输入的参数:文档矩阵trainMatrix
#由每篇文档类别标签构成的向量trainCategory
#朴素贝叶斯分类器训练函数
#trainMatrix:每个词向量中的词,在词汇表中出现的就是1
#trainMatrix:[[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0], 
#[0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0],
#[1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
#[0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0], 
#[0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1], 
#[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0]]
#该词向量中带有侮辱性的词的就是1
#trainCategory:[0, 1, 0, 1, 0, 1]
def trainNBO(trainMatrix,trainCategory):
    #一共有几个词向量
    numTrainDocs=len(trainMatrix)
    #词汇表的长度
    numWords=len(trainMatrix[0])
    #3/6 表示6个词向量中,3个带侮辱词
    pAbusive=sum(trainCategory)/float(numTrainDocs)
    #初始化概率
    p0Num=ones(numWords)
    p1Num=ones(numWords)
    p0Denom=2.0;p1Denom=2.0
    #遍历训练集trainMatrix中的所有文档
    #一旦某个词在某一文档中出现
    #该文档的总词数加1
    #两个类别都要进行同样的处理
    #i:012345
    for i in range(numTrainDocs):
        #该词向量带侮辱
        if trainCategory[i]==1:
            #向量相加
            p1Num+=trainMatrix[i]
            p1Denom+=sum(trainMatrix[i])
        else:
            p0Num+=trainMatrix[i]
            p0Denom+=sum(trainMatrix[i])
    #每个元素除以该类别的总词数
    p1Vect=log(p1Num/p1Denom)
    p0Vect=log(p0Num/p0Denom)
    return p0Vect,p1Vect,pAbusive
            
    
    
    
#朴素贝叶斯分类函数
def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):
    #元素相乘
    p1=sum(vec2Classify*p1Vec)+log(pClass1)
    p0=sum(vec2Classify*p0Vec)+log(1.0-pClass1)
    if p1>p0:
        return 1
    else:
        return 0    
    
    
def testingNB():
    listOPosts,listClasses=loadDataSet()
    myVocabList=createVocabList(listOPosts)
    trainMat=[]
    #使用词向量填充trainMat列表
    for postinDoc in listOPosts:
        Vec01=setOfWords2Vec(myVocabList,postinDoc)
        trainMat.append(Vec01)    
    p0V,p1V,pAb=trainNBO(trainMat,listClasses)
    #测试集
    testEntry=['love','my','dalmation']
    thisDoc=array(setOfWords2Vec(myVocabList,testEntry))
    #print(thisDoc)
    print(testEntry,' classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))
    testEntry=['stupid','garbage']
    thisDoc=array(setOfWords2Vec(myVocabList,testEntry))
    #print(thisDoc)
    print(testEntry,' classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))

    
def main():
    testingNB()
    #创建数据    
    #listOPosts,listClasses=loadDataSet()
    #print(listOPosts)
    #构建一个包含所有词的列表
    #myVocabList=createVocabList(listOPosts)
    #print(myVocabList)
    #returnVec=setOfWords2Vec(myVocabList,listOPosts[0])
    #print(returnVec)
    #trainMat=[]
    #使用词向量填充trainMat列表
    #for postinDoc in listOPosts:
        #传入词汇表 以及每一行词向量
        #返回的是一个与词汇表同样size的向量
        #1表示这个词在词向量中出现过
        #Vec01=setOfWords2Vec(myVocabList,postinDoc)
        #print(Vec01)
        #将01list填充trainMat
        #trainMat.append(Vec01)
    #print(trainMat)
    #print(listClasses)
    #p0V,p1V,pAB=trainNBO(trainMat,listClasses)
    #print(p0V)
    #print(p1V)
    #print(pAB)
    
if __name__=='__main__':
    main()



朴素贝叶斯分类垃圾邮件

#文件解析及完整的垃圾邮件测试函数
#返回传入的bigString中的单词
#接收一大个字符串并将其解析为字符串列表
#去掉少于两个字符的字符串,并将所有的字符串转换成小写
def textParse(bigString):
    listOfTokens=re.split(r'\W*',bigString)
    return [tok.lower() for tok in listOfTokens if len(tok)>2]


#对贝叶斯垃圾邮件分类器进行自动化处理
#导入spam与ham下的文本文件,并将它们转换为词列表
#存留交叉验证:随机选择数据中的一部分作为训练集,
#而剩余的部分作为测试集
def spamTest():
    docList=[]
    classList=[]
    fullText=[]
    for i in range(1,26):
        wordList=textParse(open('./MLiA_SourceCode/machinelearninginaction/Ch04/email/spam/%d.txt' % i).read())
        #每篇邮件中组成的list
        #[[...],[...],[...]...]
        docList.append(wordList)
        #全部邮件组成的大list
        #[...]
        fullText.extend(wordList)
        #1010组成的list
        classList.append(1)
        wordList=textParse(open('./MLiA_SourceCode/machinelearninginaction/Ch04/email/ham/%d.txt' % i).read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    #print(docList)
    #print(fullText)
    #print(classList)
    #创建词汇表——所有的单词都只出现一次
    vocabList=createVocabList(docList)
    #print(vocabList)
    #[1,2,...49]
    trainingSet=list(range(50))
    #print(trainingSet)
    testSet=[]
    #创建测试集
    #随机选取10个文件作为测试集
    for i in range(10):
        #在1-49中取随机数
        randIndex=int(random.uniform(0,len(trainingSet)))
        #print(randIndex)
        testSet.append(trainingSet[randIndex])
        #将选出来的数从训练集中delete
        del(trainingSet[randIndex])
    #[2, 6, 15, 31, 23, 12, 3, 17, 37, 47]
    #print(testSet)    
    trainMat=[]
    trainClasses=[]
    #进行训练
    for docIndex in trainingSet:
        #返回一个和词汇表size一样的list,为1的表示这个词汇在词汇表中出现过
        trainMat.append(setOfWords2Vec(vocabList,docList[docIndex]))
        trainClasses.append(classList[docIndex])
    #print(trainMat)
    #print(trainClasses)
    #计算分类所需的概率
    p0V,p1V,pSpam=trainNBO(array(trainMat),array(trainClasses))
    errorCount=0
    #进行测试
    #遍历测试集,进行分类
    for docIndex in testSet:
        wordVector=setOfWords2Vec(vocabList,docList[docIndex])
        #对测试集分类的准确性进行判断
        if classifyNB(array(wordVector),p0V,p1V,pSpam)!=classList[docIndex]:
            errorCount+=1
            print("classification error",docList[docIndex])
    #求出平均错误率
    print('the error rate is: ',float(errorCount)/len(testSet))
        
        



使用朴素贝叶斯分类器从个人广告中获取区域倾向

#使用朴素贝叶斯分类器从个人广告中获取区域倾向
#rss源:https://www.nasa.gov/rss/dyn/image_of_the_day.rss
#http://www.ftchinese.com/rss/news
#RSS源分类器及高频词去除函数
#遍历词汇表中的每个词 并统计他在文本中出现的次数
#根据出现次数从高到低对词典进行排序,最后返回排序最高的100个词
def calcMostFreq(vocabList,fullText):
    freqDict={}
    for token in vocabList:
        freqDict[token]=fullText.count(token)
    #得到词汇及其出现的次数
    #{'hours': 1, 'airbus': 1, '柯特妮': 1, ... }
    #print(freqDict)
    sortedFreq=sorted(freqDict.items(),key=operator.itemgetter(1),reverse=True)
    #进行排序
    #[('the', 32), ('http', 22), ('ftimg', 20), ... ]
    #print(sortedFreq)
    return sortedFreq[:30]
    
    
#使用两个rss源作为参数    
def localWords(feed1,feed0):
    docList=[]
    classList=[]
    fullText=[]
    minLen=min(len(feed1['entries']),len(feed0['entries']))
    for i in range(minLen):
        #将summary的内容拆分成一个个单词
        wordList=textParse(feed1['entries'][i]['summary'])
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)
        wordList=textParse(feed0['entries'][i]['summary'])
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    #创建词汇表
    vocabList=createVocabList(docList)
    
    ##增加下面三行代码会导致错误率升高
    
    #得到词汇表中出现频率最高的top30
    top30Words=calcMostFreq(vocabList,fullText)
    #将高频词汇去除
    for pairW in top30Words:
        if pairW[0] in vocabList: vocabList.remove(pairW[0])
    
    ##
    
    #创建训练集与测试集
    trainingSet=list(range(2*minLen))
    testSet=[]
    for i in range(20):
        randIndex=int(random.uniform(0,len(trainingSet)))
        testSet.append(trainingSet[randIndex])
        del(trainingSet[randIndex])
    trainMat=[]
    trainClasses=[]
    
    #开始训练
    for docIndex in trainingSet:
        trainMat.append(bagOfWords2VecMN(vocabList,docList[docIndex]))
        trainClasses.append(classList[docIndex])
    #print(trainMat)
    
    p0V,p1V,pSpam=trainNBO(array(trainMat),array(trainClasses))
    errorCount=0
    for docIndex in testSet:
        wordVector=bagOfWords2VecMN(vocabList,docList[docIndex])
        if classifyNB(array(wordVector),p0V,p1V,pSpam)!=classList[docIndex]:
            errorCount+=1
    print('the error rate is: ',float(errorCount)/len(testSet))
    return vocabList,p0V,p1V
    
    
#显示地域相关的用词
def getTopWords(ny,sf):
    import operator
    vocabList,p0V,p1V=localWords(ny,sf)
    topNY=[]
    topSF=[]
    for i in range(len(p0V)):
        #print(p0V[i])
        if p0V[i]>-5.0:
            topSF.append((vocabList[i],p0V[i]))
        if p1V[i]>-5.0:
            topNY.append((vocabList[i],p1V[i]))
    sortedSF=sorted(topSF,key=lambda pair:pair[1],reverse=True)
    print("SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF")
    for item in sortedSF:
        print(item[0])
    sortedNY=sorted(topNY,key=lambda pair:pair[1],reverse=True)
    print("NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY")
    for item in sortedNY:
        print(item[0])
        



完整代码

from numpy import *
import feedparser
import re
import operator

#词表到向量的转换
#创建实验样本,返回的是进行词条切分后的文档集合,
#还有一个类别标签——侮辱性的or非侮辱性的
def loadDataSet():
    postingList=[['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],
                 ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
                 ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
                 ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
                 ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
                 ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]
    #1 代表侮辱性文字   0代表正常言论
    classVec = [0,1,0,1,0,1]
    return postingList,classVec
    
#创建一个包含在所有文档中出现的不重复的词的列表    
def createVocabList(dataSet):
    vocabSet=set([])
    #document:['my', 'dog', 'has', 'flea', 'problems', 'help', 'please']
    for document in dataSet:
        #求并集
        vocabSet=vocabSet|set(document)
        #print(vocabSet)
    return list(vocabSet)
    
#参数为词汇表以及某个文档,输出的是文档向量
#输出的向量的每一个元素为1或0,表示词汇表中
#的单词在输入文档中是否出现
def setOfWords2Vec(vocabList,inputSet):
    #创建一个所含元素都为0的向量
    returnVec=[0]*len(vocabList)
    #遍历文档中的所有单词,如果出现了词汇表中的单词,
    #则将输出文档的对应值设为1
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)]=1
        else:
            print("the word: %s is not in my Vocabulary!"%word)
    return returnVec
    
    
#朴素贝叶斯词袋模型
#与上面的setOfWords2Vec功能基本相同,
#只是每遇到一个单词就会增加词向量中对应的值
#而不是简单地设置1
def bagOfWords2VecMN(vocabList,inputSet):
    returnVec =[0]*len(vocabList)
    for word in inputSet:
        if word in vocabList:
            returnVec[vocabList.index(word)]+=1
    return returnVec
    

    

#输入的参数:文档矩阵trainMatrix
#由每篇文档类别标签构成的向量trainCategory
#朴素贝叶斯分类器训练函数
#trainMatrix:每个词向量中的词,在词汇表中出现的就是1
#trainMatrix:[[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0], 
#[0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0],
#[1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
#[0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0], 
#[0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1], 
#[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0]]
#该词向量中带有侮辱性的词的就是1
#trainCategory:[0, 1, 0, 1, 0, 1]
def trainNBO(trainMatrix,trainCategory):
    #一共有几个词向量
    numTrainDocs=len(trainMatrix)
    #词汇表的长度
    numWords=len(trainMatrix[0])
    #3/6 表示6个词向量中,3个带侮辱词
    pAbusive=sum(trainCategory)/float(numTrainDocs)
    #初始化概率
    p0Num=ones(numWords)
    p1Num=ones(numWords)
    p0Denom=2.0;p1Denom=2.0
    #遍历训练集trainMatrix中的所有文档
    #一旦某个词在某一文档中出现
    #该文档的总词数加1
    #两个类别都要进行同样的处理
    #i:012345
    for i in range(numTrainDocs):
        #该词向量带侮辱
        if trainCategory[i]==1:
            #向量相加
            p1Num+=trainMatrix[i]
            p1Denom+=sum(trainMatrix[i])
        else:
            p0Num+=trainMatrix[i]
            p0Denom+=sum(trainMatrix[i])
    #每个元素除以该类别的总词数
    p1Vect=log(p1Num/p1Denom)
    p0Vect=log(p0Num/p0Denom)
    return p0Vect,p1Vect,pAbusive
            
    
    
    
#朴素贝叶斯分类函数
def classifyNB(vec2Classify,p0Vec,p1Vec,pClass1):
    #元素相乘
    p1=sum(vec2Classify*p1Vec)+log(pClass1)
    p0=sum(vec2Classify*p0Vec)+log(1.0-pClass1)
    if p1>p0:
        return 1
    else:
        return 0    
    
    
def testingNB():
    listOPosts,listClasses=loadDataSet()
    myVocabList=createVocabList(listOPosts)
    trainMat=[]
    #使用词向量填充trainMat列表
    for postinDoc in listOPosts:
        Vec01=setOfWords2Vec(myVocabList,postinDoc)
        trainMat.append(Vec01)    
    p0V,p1V,pAb=trainNBO(trainMat,listClasses)
    #测试集
    testEntry=['love','my','dalmation']
    thisDoc=array(setOfWords2Vec(myVocabList,testEntry))
    #print(thisDoc)
    print(testEntry,' classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))
    testEntry=['stupid','garbage']
    thisDoc=array(setOfWords2Vec(myVocabList,testEntry))
    #print(thisDoc)
    print(testEntry,' classified as: ',classifyNB(thisDoc,p0V,p1V,pAb))

    
#文件解析及完整的垃圾邮件测试函数
#返回传入的bigString中的单词
#接收一大个字符串并将其解析为字符串列表
#去掉少于两个字符的字符串,并将所有的字符串转换成小写
def textParse(bigString):
    listOfTokens=re.split(r'\W*',bigString)
    return [tok.lower() for tok in listOfTokens if len(tok)>2]


#对贝叶斯垃圾邮件分类器进行自动化处理
#导入spam与ham下的文本文件,并将它们转换为词列表
#存留交叉验证:随机选择数据中的一部分作为训练集,
#而剩余的部分作为测试集
def spamTest():
    docList=[]
    classList=[]
    fullText=[]
    for i in range(1,26):
        wordList=textParse(open('./MLiA_SourceCode/machinelearninginaction/Ch04/email/spam/%d.txt' % i).read())
        #每篇邮件中组成的list
        #[[...],[...],[...]...]
        docList.append(wordList)
        #全部邮件组成的大list
        #[...]
        fullText.extend(wordList)
        #1010组成的list
        classList.append(1)
        wordList=textParse(open('./MLiA_SourceCode/machinelearninginaction/Ch04/email/ham/%d.txt' % i).read())
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    #print(docList)
    #print(fullText)
    #print(classList)
    #创建词汇表——所有的单词都只出现一次
    vocabList=createVocabList(docList)
    #print(vocabList)
    #[1,2,...49]
    trainingSet=list(range(50))
    #print(trainingSet)
    testSet=[]
    #创建测试集
    #随机选取10个文件作为测试集
    for i in range(10):
        #在1-49中取随机数
        randIndex=int(random.uniform(0,len(trainingSet)))
        #print(randIndex)
        testSet.append(trainingSet[randIndex])
        #将选出来的数从训练集中delete
        del(trainingSet[randIndex])
    #[2, 6, 15, 31, 23, 12, 3, 17, 37, 47]
    #print(testSet)    
    trainMat=[]
    trainClasses=[]
    #进行训练
    for docIndex in trainingSet:
        #返回一个和词汇表size一样的list,为1的表示这个词汇在词汇表中出现过
        trainMat.append(setOfWords2Vec(vocabList,docList[docIndex]))
        trainClasses.append(classList[docIndex])
    #print(trainMat)
    #print(trainClasses)
    #计算分类所需的概率
    p0V,p1V,pSpam=trainNBO(array(trainMat),array(trainClasses))
    errorCount=0
    #进行测试
    #遍历测试集,进行分类
    for docIndex in testSet:
        wordVector=setOfWords2Vec(vocabList,docList[docIndex])
        #对测试集分类的准确性进行判断
        if classifyNB(array(wordVector),p0V,p1V,pSpam)!=classList[docIndex]:
            errorCount+=1
            print("classification error",docList[docIndex])
    #求出平均错误率
    print('the error rate is: ',float(errorCount)/len(testSet))
        
        
    
    
#使用朴素贝叶斯分类器从个人广告中获取区域倾向
#rss源:https://www.nasa.gov/rss/dyn/image_of_the_day.rss
#http://www.ftchinese.com/rss/news
#RSS源分类器及高频词去除函数
#遍历词汇表中的每个词 并统计他在文本中出现的次数
#根据出现次数从高到低对词典进行排序,最后返回排序最高的100个词
def calcMostFreq(vocabList,fullText):
    freqDict={}
    for token in vocabList:
        freqDict[token]=fullText.count(token)
    #得到词汇及其出现的次数
    #{'hours': 1, 'airbus': 1, '柯特妮': 1, ... }
    #print(freqDict)
    sortedFreq=sorted(freqDict.items(),key=operator.itemgetter(1),reverse=True)
    #进行排序
    #[('the', 32), ('http', 22), ('ftimg', 20), ... ]
    #print(sortedFreq)
    return sortedFreq[:30]
    
    
#使用两个rss源作为参数    
def localWords(feed1,feed0):
    docList=[]
    classList=[]
    fullText=[]
    minLen=min(len(feed1['entries']),len(feed0['entries']))
    for i in range(minLen):
        #将summary的内容拆分成一个个单词
        wordList=textParse(feed1['entries'][i]['summary'])
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(1)
        wordList=textParse(feed0['entries'][i]['summary'])
        docList.append(wordList)
        fullText.extend(wordList)
        classList.append(0)
    #创建词汇表
    vocabList=createVocabList(docList)
    
    ##增加下面三行代码会导致错误率升高
    
    #得到词汇表中出现频率最高的top30
    top30Words=calcMostFreq(vocabList,fullText)
    #将高频词汇去除
    for pairW in top30Words:
        if pairW[0] in vocabList: vocabList.remove(pairW[0])
    
    ##
    
    #创建训练集与测试集
    trainingSet=list(range(2*minLen))
    testSet=[]
    for i in range(20):
        randIndex=int(random.uniform(0,len(trainingSet)))
        testSet.append(trainingSet[randIndex])
        del(trainingSet[randIndex])
    trainMat=[]
    trainClasses=[]
    
    #开始训练
    for docIndex in trainingSet:
        trainMat.append(bagOfWords2VecMN(vocabList,docList[docIndex]))
        trainClasses.append(classList[docIndex])
    #print(trainMat)
    
    p0V,p1V,pSpam=trainNBO(array(trainMat),array(trainClasses))
    errorCount=0
    for docIndex in testSet:
        wordVector=bagOfWords2VecMN(vocabList,docList[docIndex])
        if classifyNB(array(wordVector),p0V,p1V,pSpam)!=classList[docIndex]:
            errorCount+=1
    print('the error rate is: ',float(errorCount)/len(testSet))
    return vocabList,p0V,p1V
    
    
#显示地域相关的用词
def getTopWords(ny,sf):
    import operator
    vocabList,p0V,p1V=localWords(ny,sf)
    topNY=[]
    topSF=[]
    for i in range(len(p0V)):
        #print(p0V[i])
        if p0V[i]>-5.0:
            topSF.append((vocabList[i],p0V[i]))
        if p1V[i]>-5.0:
            topNY.append((vocabList[i],p1V[i]))
    sortedSF=sorted(topSF,key=lambda pair:pair[1],reverse=True)
    print("SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF**SF")
    for item in sortedSF:
        print(item[0])
    sortedNY=sorted(topNY,key=lambda pair:pair[1],reverse=True)
    print("NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY**NY")
    for item in sortedNY:
        print(item[0])
        
    
    
#rss源:https://www.nasa.gov/rss/dyn/image_of_the_day.rss
#http://www.ftchinese.com/rss/news
def main():
    ny=feedparser.parse('https://www.nasa.gov/rss/dyn/image_of_the_day.rss')
    sf=feedparser.parse('http://www.ftchinese.com/rss/news')
    #vocabList,pSF,pNY=localWords(ny,sf)
    getTopWords(ny,sf)
    #vocabList,pSF,pNY=localWords(ny,sf)
    #spamTest()
    #testingNB()
    #创建数据    
    #listOPosts,listClasses=loadDataSet()
    #print(listOPosts)
    #构建一个包含所有词的列表
    #myVocabList=createVocabList(listOPosts)
    #print(myVocabList)
    #returnVec=setOfWords2Vec(myVocabList,listOPosts[0])
    #print(returnVec)
    #trainMat=[]
    #使用词向量填充trainMat列表
    #for postinDoc in listOPosts:
        #传入词汇表 以及每一行词向量
        #返回的是一个与词汇表同样size的向量
        #1表示这个词在词向量中出现过
        #Vec01=setOfWords2Vec(myVocabList,postinDoc)
        #print(Vec01)
        #将01list填充trainMat
        #trainMat.append(Vec01)
    #print(trainMat)
    #print(listClasses)
    #p0V,p1V,pAB=trainNBO(trainMat,listClasses)
    #print(p0V)
    #print(p1V)
    #print(pAB)
    
if __name__=='__main__':
    main()

Shimmer
105 声望30 粉丝

A Pig.